// 导入数据库操作模块
const db = require('../db/index')
// 导入加密模块
const bcrypt = require('bcryptjs')
// 导入生成token的包
const jwt = require('jsonwebtoken')
// 导入验证表单的包
const Joi = require('joi');
// 导入全局配置文件
const config = require('../config')



// 定义数据验证schema
const schema_login = Joi.object({
    username: Joi.string().min(4).max(20).required().alphanum().messages({
      'string.min': '用户名至少需要 4 个字符',
      'string.max': '用户名最多 20 个字符',
      'string.alphanum': '用户名只能包含字母和数字'
    }),
    password: Joi.string().min(6).max(15).required().pattern(/^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]+$/).messages({
        'string.min': '至少包含 6 个字符',
        'string.max': '最多 15 个字符',
        'string.pattern.base': '密码必须为6~15位字母、数字'
    })
})
const schema_register = Joi.object({
    name: Joi.string().pattern(/^[\u4e00-\u9fa5]+$/).message({
        'string.pattern.base': '姓名只能包含汉字'
    }),
    phone: Joi.string().pattern(/^1[3-9]\d{9}$/).message({
        'string.pattern.base': '无效的电话号码'
    }),
    email: Joi.string().pattern(/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/).message({
        'string.pattern.base': '无效的邮箱'
    }),
    username: Joi.string().min(4).max(20).alphanum().messages({
        'string.min': '用户名至少需要 4 个字符',
        'string.max': '用户名最多 20 个字符',
        'string.alphanum': '用户名只能包含字母和数字'
    }),
    password: Joi.string().min(6).max(15).pattern(/^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]+$/).messages({
        'string.min': '至少包含 6 个字符',
        'string.max': '最多 15 个字符',
        'string.pattern.base': '密码必须为6~15位字母、数字'
    }),
    passwordDb: Joi.string().valid(Joi.ref('password')).messages({
      'any.only': '确认密码必须与密码一致'
    }),
    sex: Joi.string().optional(), // 性别字段，未进行验证
    birthday: Joi.string().optional()
})

const schema_updatePwd = Joi.object({
    pre_pwd: Joi.string().min(6).max(15).pattern(/^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]+$/).messages({
        'string.min': '至少包含 6 个字符',
        'string.max': '最多 15 个字符',
        'string.pattern.base': '密码必须为6~15位字母、数字'
    }),
    password: Joi.string().min(6).max(15).pattern(/^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]+$/).messages({
        'string.min': '至少包含 6 个字符',
        'string.max': '最多 15 个字符',
        'string.pattern.base': '密码必须为6~15位字母、数字'
    }),
    passwordDb: Joi.string().valid(Joi.ref('password')).messages({
      'any.only': '确认密码必须与密码一致'
    })
}).unknown()

const schema_updateMsg = Joi.object({
    name: Joi.string().pattern(/^[\u4e00-\u9fa5]+$/).message({
        'string.pattern.base': '姓名只能包含汉字'
    }).allow(''),
    phone: Joi.string().pattern(/^1[3-9]\d{9}$/).message({
        'string.pattern.base': '无效的电话号码'
    }).allow(''),
    email: Joi.string().pattern(/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/).message({
        'string.pattern.base': '无效的邮箱'
    }).allow(''),
    username: Joi.string().min(4).max(20).alphanum().messages({
        'string.min': '用户名至少需要 4 个字符',
        'string.max': '用户名最多 20 个字符',
        'string.alphanum': '用户名只能包含字母和数字'
    }).allow(''),
    sex: Joi.string().optional().allow(''), // 性别字段，未进行验证
    birthday: Joi.string().optional().allow('')
}).unknown();

exports.login = (req, res) => {
    const user = req.body;
    console.log(user)

    // 检查输入
    if (!user.username || !user.password) {
        return res.send({
            status: 1,
            msg: '输入不能为空！'
        });
    }

    // 查找用户
    db.query('SELECT * FROM user WHERE username=?', user.username, (err, result) => {
        if (err) {
            return res.send({
                status: 1,
                msg: err
            });
        }

        // 用户不存在
        if (result.length !== 1) {
            return res.send({
                status: 1,
                msg: '该用户不存在！'
            });
        }

        // 验证密码
        if (bcrypt.compareSync(user.password, result[0].password)) {
            // 生成 token
            const userData = { ...result[0], password: '', user_pic: '' };
            const token = jwt.sign({ user: userData }, config.jwtSecretKey, { expiresIn: '10h' });

            // 将过期时间转换为毫秒
            const expiresInMilliseconds = Date.now() + 10 * 60 * 60 * 1000; // 10 小时后过期

            return res.send({
                status: 0,
                msg: '登录成功',
                token: 'Bearer ' + token,
                expireIn: expiresInMilliseconds, // 发送过期时间
                data: userData
            });
        } else {
            // 密码错误
            return res.send({
                status: 1,
                msg: '密码错误'
            });
        }
    });
};


exports.register = (req,res)=>{
    const user = req.body
    console.log(user)
    if(!user.username||!user.password||!user.name||!user.birthday||!user.phone||!user.email||!user.sex){
        return res.send({
            status: 1,
            msg: '信息不能为空！'
        })
    }
    // 验证请求数据
    const { error } = schema_register.validate(req.body);
    if (error) {
        // 返回验证错误
        return res.send({
            status: 1,
            msg: error.details[0].message
        })
    }
    db.query('select * from user where username=?',user.username,(err,result)=>{
        // 查询失败
        if(err){
            return res.send({
                status:1,
                msg:err
            })
        }
        // 判断用户名是否被占用
        if(result.length>0){    //被占用了
            return res.send({
                status:1,
                msg:'该用户名已被占用，请更换其他用户名！'
            })
        }
        // 未被占用,进行注册操作
        // 为确保用户信息安全，使用bcrypt.hashSync()对密码进行加密
        user.password = bcrypt.hashSync(user.password,10)
        // 新账号注册到数据库
        db.query('insert into user set ?',{ 
            username: user.username, 
            password: user.password,
            name: user.name,
            birthday: user.birthday,
            phone: user.phone,
            email: user.email,
            sex: user.sex,
            role: user.role || 'user',
            create_at: new Date().toISOString().slice(0, 19).replace('T', ' ')
        },(err,result)=>{
            if(err){
                return res.send({
                    status: 1,
                    msg: err
                })
            }
            // 判断影响行数是否为1
            if(result.affectedRows !== 1){
                return res.send({
                    status: 1,
                    msg: '注册用户失败，请稍后再试！'
                })
            }
            return res.json({
                status: 0,
                msg: '注册成功！'
            })
        })
    })  
}

exports.updatePwd = async (req, res) => {
    const data = req.body;

    // 判断输入是否为空
    if (!data.pre_pwd || !data.password || !data.user_id) {
        return res.send({
            status: 1,
            msg: '输入不能为空！'
        });
    }

    // 验证请求数据格式
    const { error } = schema_updatePwd.validate(data);
    if (error) {
        return res.send({
            status: 1,
            msg: error.details[0].message
        });
    }

    const { pre_pwd, password, user_id } = data;

    // 新旧密码不能一样
    if (pre_pwd === password) {
        return res.send({
            status: 1,
            msg: '新密码不能与旧密码相同！'
        });
    }

    // 查询用户
    db.query('SELECT * FROM user WHERE id = ?', [user_id], async (err, result) => {
        if (err) {
            return res.send({
                status: 1,
                msg: '数据库查询错误: ' + err
            });
        }

        // 检查用户是否存在
        if (result.length === 0) {
            return res.send({
                status: 1,
                msg: '用户未找到'
            });
        }

        // 检查原密码是否正确
        const user = result[0];
        const isMatch = bcrypt.compareSync(pre_pwd, user.password);
        if (!isMatch) {
            return res.send({
                status: 1,
                msg: '原密码错误'
            });
        }

        // 密码加密
        const hashedPassword = await bcrypt.hash(password, 10); // 使用异步加密

        // 更新用户密码
        db.query('UPDATE user SET password = ?, updated_at = NOW() WHERE id = ?', [hashedPassword, user_id], (err, result) => {
            if (err) {
                return res.send({
                    status: 1,
                    msg: '更新密码错误: ' + err
                });
            }

            return res.send({
                status: 0,
                msg: '修改成功！'
            });
        });
    });
};

// 修改用户信息
exports.updateMsg = async (req, res) => {
    console.log('发来了', req.body);
    const { name, sex, birthday, phone, email, username, user_id } = req.body;

    // 检查输入是否为空
    if (!name && !sex && !birthday && !phone && !email && !username) {
        return res.send({
            status: 1,
            msg: '输入不能为空'
        });
    }

    // 确保 user_id 存在
    if (!user_id) {
        return res.send({
            status: 1,
            msg: '用户ID不能为空'
        });
    }

    // 验证请求数据
    const { error } = schema_updateMsg.validate(req.body);
    if (error) {
        // 返回验证错误
        return res.send({
            status: 1,
            msg: error.details[0].message
        });
    }

    // 构造更新的字段
    const updates = {};
    if (name) updates.name = name;
    if (sex) updates.sex = sex;

    // 处理生日字段
    if (birthday) {
        const parsedBirthday = new Date(birthday);
        if (isNaN(parsedBirthday.getTime())) {
            return res.send({
                status: 1,
                msg: '无效的生日日期'
            });
        }
        updates.birthday = parsedBirthday; // 存储为 Date 对象
    }

    if (phone) updates.phone = phone;
    if (email) updates.email = email;
    if (username) {
        updates.username = username;

        // 查询用户名是否被占用
        const usernameCheck = await new Promise((resolve, reject) => {
            db.query('SELECT * FROM user WHERE username = ?', [username], (err, result) => {
                if (err) {
                    return reject(err);
                }
                resolve(result.length > 0); // 返回用户名是否被占用
            });
        });

        // 判断用户名是否被占用
        if (usernameCheck) {
            return res.send({
                status: 1,
                msg: '该用户名已被占用，请更换其他用户名！'
            });
        }
    }

    // 构建 SQL 更新语句
    const updateFields = Object.keys(updates).map(key => `${key} = ?`).join(', ');
    if (updateFields.length === 0) {
        return res.send({
            status: 1,
            msg: '没有可更新的字段'
        });
    }
    const updateValues = Object.values(updates);

    // 执行更新语句
    const sql = `UPDATE user SET ${updateFields}, updated_at = NOW() WHERE id = ?`;
    db.query(sql, [...updateValues, user_id], (err, result) => {
        if (err) {
            return res.send({
                status: 1,
                msg: '更新用户信息失败: ' + err
            });
        }

        if (result.affectedRows === 0) {
            return res.send({
                status: 1,
                msg: '未找到指定用户'
            });
        }

        return res.send({
            status: 0,
            msg: '用户信息更新成功'
        });
    });
};





